home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / Doslists.c < prev    next >
C/C++ Source or Header  |  1996-05-04  |  11KB  |  538 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysDosLists.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    void MakeAssignList ( void );
  12.    *    void MakeVolumeList ( void );
  13.    *    void RSysLockList ( void );
  14.    *    void SysCLIList ( void );
  15.    *    void SysResidentList ( void );
  16.    *    void SysResidentProg ( void );
  17.    *
  18.    *      --- Lokale  Routinen ---
  19.    *
  20.    *
  21.    * Bemerkungen:
  22.    *      Erzeugung von Listen der DOS-Library.
  23.    *
  24.    * Erstellungsdatum:
  25.    *      07-Jul-93     Rolf Böhme
  26.    *
  27.    * Änderungen:
  28.    *      07-Jul-93     Rolf Böhme        Erstellung
  29.    *
  30.    ***************************************************************************
  31.  */
  32.  
  33. #include "RSys.h"
  34. #include "protos.h"
  35.  
  36.  /*
  37.   * MakeAssignList() erzeugt eine Liste aller Assigns im
  38.   * System
  39.   */
  40. void
  41. MakeAssignList (void)
  42. {
  43.   int i = 0;
  44.   char helpdir[MAXFULLNAME], dir[39];
  45.   DOSLIST *dl;
  46.   BPTR lock;
  47.  
  48.   DPOS;
  49.  
  50.   countentries = CountDevices (LDF_ASSIGNS);
  51.  
  52.   if (NoEntries ())
  53.     return;
  54.  
  55.   Entries = AllocScrollEntries (countentries);
  56.  
  57.   dl = LockDosList (LDF_ASSIGNS | LDF_READ);
  58.  
  59.   while ((dl = NextDosEntry (dl, LDF_ASSIGNS | LDF_READ)) && (i < countentries))
  60.     {
  61.       B2CStr (Entries[i].se_obj_id.fullname, dl->dol_Name);
  62.       strcat (Entries[i].se_obj_id.fullname, ":");
  63.  
  64.       if (lock = Lock ((UBYTE *) Entries[i].se_obj_id.fullname, ACCESS_READ))
  65.     {
  66.       NameFromLock (lock, (UBYTE *) helpdir, 107);
  67.       strncpy (dir, helpdir, 38);
  68.  
  69.       UnLock (lock);
  70.     }
  71.       else
  72.     strcpy (dir, field[NO_LOCK]);
  73.  
  74.       sprintf (Entries[i].se_Entry, EntryAttr[ASSIGNS].ea_dataformat,
  75.            Entries[i].se_obj_id.fullname, dir);
  76.  
  77.       AddNodeToList (i, SORT, 0);
  78.  
  79.       i++;
  80.     }
  81.  
  82.   UnLockDosList (LDF_ASSIGNS | LDF_READ);
  83.  
  84.   PrintStatistics ();
  85.  
  86.   return;
  87. }
  88.  
  89.  /*
  90.   * MakeVolumeList() erzeugt eine Liste aller Volumes im
  91.   * System
  92.   */
  93. void
  94. MakeVolumeList (void)
  95. {
  96.   int i = 0;
  97.   DOSLIST *dl;
  98.   long free, used, percentused;
  99.   char state[6], type[6];
  100.  
  101.   DPOS;
  102.  
  103.   DisableSysRequest (TRUE);
  104.  
  105.   countentries = CountDevices (LDF_VOLUMES);
  106.  
  107.   if (NoEntries ())
  108.     return;
  109.  
  110.   Entries = AllocScrollEntries (countentries);
  111.  
  112.   dl = LockDosList (LDF_VOLUMES | LDF_READ);
  113.  
  114.   while ((dl = NextDosEntry (dl, LDF_VOLUMES | LDF_READ)) && (i < countentries))
  115.     {
  116.       B2CStr (Entries[i].se_obj_id.fullname, dl->dol_Name);
  117.       strcat (Entries[i].se_obj_id.fullname, ":");
  118.  
  119.       FreeBytes (Entries[i].se_obj_id.fullname, &free, &used, &percentused, state, type);
  120.  
  121.       sprintf (Entries[i].se_Entry, EntryAttr[VOLUMES].ea_dataformat,
  122.            Entries[i].se_obj_id.fullname,
  123.            free, used, percentused,
  124.            (percentused > 90L) ? '*' : ' ',
  125.            state, type);
  126.  
  127.       AddNodeToList (i, SORT, 0);
  128.  
  129.       i++;
  130.     }
  131.  
  132.   UnLockDosList (LDF_VOLUMES | LDF_READ);
  133.  
  134.   DisableSysRequest (FALSE);
  135.  
  136.   PrintStatistics ();
  137.  
  138.   return;
  139. }
  140.  
  141.  
  142. void
  143. RSysLockList (void)
  144. {
  145.   LIST *DispList;
  146.   REMEMBER *DispKey = NULL;
  147.   NODE *node;
  148.   RSYS_LOCKENTRY *LockNode;
  149.   char *b_ptr;
  150.   char *ac_ptr;
  151.   BPTR lo;
  152.   DOSLIST *dl;
  153.   FILELOCK *lptr, *alptr = NULL;
  154.   char buffer[MAXFULLNAME];
  155.   char vol_buffer[MAXFULLNAME];
  156.   int i;
  157.   int retval;            /*GMD */
  158.   int lock_flag;
  159.  
  160.   HandleHelp (MN_RSysLockList);
  161.  
  162.   PrintHeader (VOLLOCKS, NULL);
  163.  
  164.   EmptyListView ();
  165.  
  166.   DispList = AllocRemember (&DispKey, sizeof (LIST), MEMF_CLEAR);
  167.   if (DispList)
  168.     {
  169.       NewList (DispList);
  170.       Forbid ();
  171.       dl = LockDosList (LDF_VOLUMES | LDF_READ);
  172.  
  173.       while (dl)
  174.     {
  175.  
  176.       if ((dl->dol_Type == DLT_VOLUME) && B2CStr (buffer, dl->dol_Name))
  177.         {
  178.           strcat (buffer, ":");
  179.           strcpy (vol_buffer, buffer);
  180.           strcat (vol_buffer, " <inv lock>");
  181.  
  182.           if (lo = Lock ((UBYTE *) buffer, ACCESS_READ))
  183.         {
  184.           for (lptr = BPTR_TO_C (FileLock, lo), lock_flag = TRUE;
  185.                lptr != NULL;
  186.                lptr = BPTR_TO_C (FileLock, lptr->fl_Link)
  187.             )
  188.  
  189.             {
  190.               retval = DOSTRUE;
  191.               LockNode = AllocRemember (&DispKey,
  192.                        sizeof (RSYS_LOCKENTRY), MEMF_CLEAR);
  193.  
  194.               LockNode->node.ln_Name = AllocRemember (&DispKey,
  195.                                BUFSIZE, MEMF_CLEAR);
  196.  
  197.               /*
  198.                * test for valid lock
  199.                *
  200.                */
  201.               if ((TypeOfMem (lptr) == 0) ||
  202.               (BPTR_TO_C (FileLock, lptr->fl_Volume) !=
  203.                (FILELOCK *) dl))
  204.             {
  205.               lock_flag = FALSE;    /* invalid lock */
  206.               ac_ptr = "";
  207.               b_ptr = vol_buffer;
  208.             }
  209.               else
  210.             {
  211.  
  212.               ac_ptr = "!!!!!";
  213.               b_ptr = "<NameFromLock Fail>";
  214.               retval = NameFromLock (C_TO_BPTR (lptr),
  215.                      (UBYTE *) buffer, MAXFULLNAME - 1);
  216.  
  217.               if (retval != DOSFALSE)
  218.                 {
  219.                   switch (-lptr->fl_Access)
  220.                 {
  221.                 case 0:
  222.                   ac_ptr = "--0--";
  223.                   break;
  224.  
  225.                 case 1:
  226.                   ac_ptr = "WRITE";
  227.                   break;
  228.  
  229.                 case 2:
  230.                   ac_ptr = "READ";
  231.                   break;
  232.  
  233.                 default:
  234.                   ac_ptr = "?????";
  235.                   break;
  236.                 }
  237.  
  238.                   b_ptr = buffer;
  239.                 }
  240.             }
  241.  
  242.               sprintf (LockNode->node.ln_Name,
  243.                    EntryAttr[VOLLOCKS].ea_dataformat,
  244.                    lptr,
  245.                    b_ptr, ac_ptr);
  246.  
  247.               strncpy (LockNode->obj.fullname, buffer, MAXFULLNAME);
  248.  
  249.               LockNode->obj.address = lptr;
  250.               AddNodeSorted (DispList, &(LockNode->node), 9);
  251.  
  252.               if ((lock_flag == FALSE) || (retval == DOSFALSE))
  253.             break;    /* bad lock */
  254.  
  255.               if (BPTR_TO_C (FileLock, lptr->fl_Link) == alptr)
  256.             break;
  257.  
  258.               alptr = lptr;
  259.  
  260.             }        /*end-for */
  261.  
  262.           UnLock (lo);
  263.  
  264.         }        /*end-if lo */
  265.  
  266.         }            /*end-if dl */
  267.  
  268.       dl = NextDosEntry (dl, LDF_VOLUMES | LDF_READ);
  269.  
  270.     }            /*end-while */
  271.  
  272.       UnLockDosList (LDF_VOLUMES | LDF_READ);
  273.  
  274.       Permit ();
  275.  
  276.       countentries = CountNodes (DispList);
  277.  
  278.       if (!NoEntries ())
  279.     {
  280.       Entries = AllocScrollEntries (countentries);
  281.  
  282.       for (node = DispList->lh_Head, i = 0;
  283.            node->ln_Succ && (i < countentries);
  284.            node = node->ln_Succ, i++)
  285.         {
  286.           strcpy (Entries[i].se_Entry, node->ln_Name);
  287.           Entries[i].se_obj_id.address = ((RSYS_LOCKENTRY *) node)->obj.address;
  288.           strcpy (Entries[i].se_obj_id.fullname,
  289.               ((RSYS_LOCKENTRY *) node)->obj.fullname);
  290.         }
  291.  
  292.       CreateEntryList (SORT, 9);
  293.     }
  294.  
  295.       FreeRemember (&DispKey, TRUE);
  296.  
  297.       PrintStatistics ();
  298.     }
  299.   else
  300.     ErrorHandle ("Tmp LockList", MEMORY_ERR, ALLOC_FAIL, KILL);
  301.  
  302.   return;
  303. }
  304.  
  305. /*
  306.  * SysResidentList() listet die residenten Handler
  307.  * aller Devices auf
  308.  */
  309. void
  310. SysResidentList (void)
  311. {
  312.   int i = 0;
  313.   FILESYSSTARTUPMSG *fssm;
  314.   DOSLIST *dl;
  315.  
  316.   char devhandler[100];
  317.  
  318.   DPOS;
  319.  
  320.   HandleHelp (MN_SysResidentList);
  321.  
  322.   PrintHeader (DEVS, NULL);
  323.  
  324.   EmptyListView ();
  325.  
  326.   countentries = CountDevices (CNTMASK);
  327.  
  328.   if (NoEntries ())
  329.     return;
  330.  
  331.   Entries = AllocScrollEntries (countentries);
  332.  
  333.   DisableSysRequest (TRUE);
  334.  
  335.   dl = LockDosList (MASK);
  336.  
  337.   while ((dl = NextDosEntry (dl, MASK)) && (i < countentries))
  338.     {
  339.       B2CStr (Entries[i].se_obj_id.fullname, dl->dol_Name);
  340.       strcat (Entries[i].se_obj_id.fullname, ":");
  341.  
  342.       Entries[i].se_obj_id.address = dl;
  343.  
  344.       if (dl->dol_Task && (fssm = B2C (dl->dol_misc.dol_handler.dol_Startup)))
  345.     {
  346.       B2CStr (devhandler, fssm->fssm_Device);
  347.     }
  348.       else if (dl->dol_misc.dol_handler.dol_Handler)
  349.     {
  350.       B2CStr (devhandler, dl->dol_misc.dol_handler.dol_Handler);
  351.     }
  352.       else
  353.     {
  354.       strcpy (devhandler, field[NO_HANDLER]);
  355.     }
  356.  
  357.       sprintf (Entries[i].se_Entry,
  358.            EntryAttr[DEVS].ea_dataformat,
  359.            Entries[i].se_obj_id.fullname,
  360.            devhandler);
  361.  
  362.       i++;
  363.     }
  364.  
  365.   countentries = i;
  366.  
  367.   UnLockDosList (MASK);
  368.  
  369.   DisableSysRequest (FALSE);
  370.  
  371.   CreateEntryList (SORT, 0);
  372.  
  373.   PrintStatistics ();
  374.  
  375.   return;
  376. }
  377.  
  378. /*
  379.  * SysCLIList() erzeugt eine Liste aller CLI's im System
  380.  */
  381. void
  382. SysCLIList (void)
  383. {
  384.   int clicnt, i = 0;
  385.   PROCESS *cliproc;
  386.  
  387.   HandleHelp (MN_SysCLIList);
  388.  
  389.   DPOS;
  390.  
  391.   PrintHeader (CLI, NULL);
  392.  
  393.   EmptyListView ();
  394.  
  395.   countentries = MaxCli ();
  396.  
  397.   if (NoEntries ())
  398.     return;
  399.  
  400.   Entries = AllocScrollEntries (countentries);
  401.  
  402.   Forbid ();
  403.  
  404.   for (clicnt = 1; clicnt < countentries; clicnt++)
  405.     {
  406.       cliproc = FindCliProc ((ULONG) clicnt);
  407.       if (cliproc)
  408.     {
  409.       savestrcpy (Entries[i].se_obj_id.fullname, &(cliproc->pr_Task.tc_Node),
  410.               MAXFULLNAME - 1, NT_PROCESS);
  411.       Entries[i].se_obj_id.address = cliproc;
  412.  
  413.       sprintf (Entries[i].se_Entry, EntryAttr[CLI].ea_dataformat,
  414.            Entries[i].se_obj_id.address,
  415.            (char) cliproc->pr_TaskNum,
  416.            Entries[i].se_obj_id.fullname,
  417.            cliproc->pr_Task.tc_Node.ln_Pri,
  418.            ((ULONG) cliproc->pr_Task.tc_SPUpper -
  419.             (ULONG) cliproc->pr_Task.tc_SPLower));
  420.  
  421.       i++;
  422.     }
  423.     }
  424.  
  425.   countentries = i;
  426.  
  427.   Permit ();
  428.  
  429.   CreateEntryList (SORT, 9);
  430.  
  431.   PrintStatistics ();
  432.  
  433.   return;
  434. }
  435.  
  436.  
  437. void
  438. SysResidentProg (void)
  439. {
  440.   char name[BUFSIZE];
  441.   ROOTNODE *RN = DOSBase->dl_Root;
  442.   DOSINFO *di = (DOSINFO *) BADDR (RN->rn_Info);
  443.   RSYS_RESIDENTLIST *RL = (RSYS_RESIDENTLIST *) BADDR (di->di_NetHand),
  444.    *loop = RL;
  445.   int cnt = 0, i;
  446.  
  447.   DPOS;
  448.  
  449.   HandleHelp (MN_SysResidentProg);
  450.  
  451.   PrintHeader (RESIDENTS, NULL);
  452.  
  453.   EmptyListView ();
  454.  
  455.   PrintInfo ("Counting residents", NO_SPEAK, 0);
  456.  
  457.   Forbid ();
  458.  
  459.   for (loop = RL; loop; loop = (RSYS_RESIDENTLIST *) BADDR (loop->rl_Next))
  460.     cnt++;
  461.  
  462.   Permit ();
  463.  
  464.   countentries = cnt;
  465.  
  466.   if (NoEntries ())
  467.     return;
  468.  
  469.   Entries = AllocScrollEntries (countentries);
  470.  
  471.   Forbid ();
  472.  
  473.   cnt = 0;
  474.  
  475.   for (loop = RL; loop && (cnt < countentries); loop = (RSYS_RESIDENTLIST *) BADDR (loop->rl_Next))
  476.     {
  477.       for (i = 0; (i < *(UBYTE *) & loop->rl_SegName) && (i < BUFSIZE); i++)
  478.     name[i] = (char) *(UBYTE *) (((BPTR) & loop->rl_SegName) + i + 1L);
  479.  
  480.       name[i] = STRINGEND;
  481.  
  482.       Entries[cnt].se_obj_id.address = loop;
  483.  
  484.       sprintf (Entries[cnt].se_Entry, EntryAttr[RESIDENTS].ea_dataformat,
  485.            Entries[cnt].se_obj_id.address,
  486.            name,
  487.            loop->rl_UseCount,
  488.            ((loop->rl_UseCount >= 0) ? "EXTERNAL" :
  489.         ((loop->rl_UseCount == -1) ? "SYSTEM" : "INTERNAL")));
  490.  
  491.       cnt++;
  492.     }
  493.  
  494.   countentries = cnt;
  495.  
  496.   Permit ();
  497.  
  498.   CreateEntryList (SORT, 9);
  499.  
  500.   PrintStatistics ();
  501.  
  502.   return;
  503. }
  504.  
  505. void
  506. RSysFaultMessages (void)
  507. {
  508.   int cnt;
  509.   UBYTE fmsg[BUFSIZE];
  510.  
  511. /*   HandleHelp(MN_SysResidentProg); */
  512.  
  513.   PrintHeader (FAULTMSG, NULL);
  514.  
  515.   EmptyListView ();
  516.  
  517.   countentries = 256;
  518.  
  519.   Entries = AllocScrollEntries (countentries);
  520.  
  521.   sprintf (Entries[0].se_Entry, EntryAttr[FAULTMSG].ea_dataformat,
  522.        0, field[NO_FIELD]);
  523.  
  524.   for (cnt = 1; cnt < countentries; cnt++)
  525.     {
  526.       Fault (cnt, (UBYTE *) "-", fmsg, BUFSIZE - 1);
  527.  
  528.       sprintf (Entries[cnt].se_Entry, EntryAttr[FAULTMSG].ea_dataformat,
  529.            cnt, &fmsg[2]);
  530.     }
  531.  
  532.   CreateEntryList (NO_SORT, 0);
  533.  
  534.   PrintStatistics ();
  535.  
  536.   return;
  537. }
  538.